/*---------------------------------------------------------------------------/
/  Petit FatFs - FAT file system module include file  R0.01a   (C)ChaN, 2009
/----------------------------------------------------------------------------/
/ Petit FatFs module is an open source software to implement FAT file system to
/ small embedded systems. This is a free software and is opened for education,
/ research and commercial developments under license policy of following trems.
/
/  Copyright (C) 2009, ChaN, all right reserved.
/
/ * The Petit FatFs module is a free software and there is NO WARRANTY.
/ * No restriction on use. You can use, modify and redistribute it for
/   personal, non-profit or commercial use UNDER YOUR RESPONSIBILITY.
/ * Redistributions of source code must retain the above copyright notice.
/----------------------------------------------------------------------------*/

#include <stdint.h>
#include "types.h"
#include "diskio.h"


typedef WORD WCHAR;


/*---------------------------------------------------------------------------/
/ Petit FatFs Configuration Options
/
/ CAUTION! Do not forget to make clean the project after any changes to
/ the configuration options.
/
/----------------------------------------------------------------------------*/
#ifndef _FATFS
#define _FATFS

#define _WORD_ACCESS    1
/* The _WORD_ACCESS option defines which access method is used to the word
/  data in the FAT structure.
/
/   0: Byte-by-byte access. Always compatible with all platforms.
/   1: Word access. Do not choose this unless following condition is met.
/
/  When the byte order on the memory is big-endian or address miss-aligned
/  word access results incorrect behavior, the _WORD_ACCESS must be set to 0.
/  If it is not the case, the value can also be set to 1 to improve the
/  performance and code efficiency. */


#define _USE_DIR    1
/* To enable pf_opendir and pf_readdir function, set _USE_DIR to 1. */


#define _USE_LSEEK  0
/* To enable pf_lseek function, set _USE_LSEEK to 1. */


#define _FS_FAT32   1
/* To enable FAT32 support, set _FS_FAT32 to 1. */
/*
#define _FS_RPATH 1
*/
#define _USE_LFN  1

#define _MAX_LFN 64

/*#define _DF1S 0
#define IsDBCS1(c)  0
#define IsDBCS2(c)  0
#define IsUpper(c)  (((c)>='A')&&((c)<='Z'))
#define IsLower(c)  (((c)>='a')&&((c)<='z'))
*/
/* End of configuration options. Do not change followings without care.     */
/*--------------------------------------------------------------------------*/


#if _FS_FAT32
#define CLUST   DWORD
#else
#define CLUST   WORD
#endif


typedef char XCHAR;

/* File system object structure */

typedef struct _FATFS_ {
    BYTE    fs_type;    /* FAT sub type */
    BYTE    csize;      /* Number of sectors per cluster */
    BYTE    flag;       /* File status flags */
    BYTE    csect;      /* File sector address in the cluster */
    WORD    n_rootdir;  /* Number of root directory entries (0 on FAT32) */
    BYTE*   buf;        /* Pointer to the disk access buffer */
    CLUST   max_clust;  /* Maximum cluster# + 1. Number of clusters is max_clust - 2 */
    DWORD   fatbase;    /* FAT start sector */
    DWORD   dirbase;    /* Root directory start sector (Cluster# on FAT32) */
    DWORD   database;   /* Data start sector */
    DWORD   fptr;       /* File R/W pointer */
    DWORD   fsize;      /* File size */
    CLUST   org_clust;  /* File start cluster */
    CLUST   curr_clust; /* File current cluster */
    DWORD   dsect;      /* File current data sector */
} FATFS;



/* Directory object structure */

typedef struct _DIR_ {
    WORD    index;      /* Current read/write index number */
    BYTE*   fn;         /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
    CLUST   sclust;     /* Table start cluster (0:Static table) */
    CLUST   clust;      /* Current cluster */
    DWORD   sect;       /* Current sector */
#if _USE_LFN
    WCHAR*  lfn;        /* Pointer to the LFN working buffer */
    WORD    lfn_idx;    /* Last matched LFN index number (0xFFFF:No LFN) */
#endif
} DIR;



/* File status structure */

typedef struct _FILINFO_ {
    DWORD   fsize;      /* File size */
    WORD    fdate;      /* Last modified date */
    WORD    ftime;      /* Last modified time */
    BYTE    fattrib;    /* Attribute */
    char    fname[13];  /* File name */
#if _USE_LFN
    char*   lfname;     /* Pointer to the LFN buffer */
    int     lfsize;     /* Size of LFN buffer [chrs] */
#endif
} FILINFO;



/* File function return code (FRESULT) */

typedef enum {
    FR_OK = 0,          /* 0 */
    FR_DISK_ERR,        /* 1 */
    FR_NOT_READY,       /* 2 */
    FR_NO_FILE,         /* 3 */
    FR_NO_PATH,         /* 4 */
    FR_INVALID_NAME,    /* 5 */
    FR_STREAM_ERR,      /* 6 */
    FR_INVALID_OBJECT,  /* 7 */
    FR_NOT_ENABLED,     /* 8 */
    FR_NO_FILESYSTEM    /* 9 */
} FRESULT;



/*--------------------------------------------------------------*/
/* Petit FatFs module application interface                     */

FRESULT pf_mount (FATFS*);              /* Mount/Unmount a logical drive */
FRESULT pf_open (const char*);          /* Open a file */

FRESULT pf_read (void*, WORD, WORD*);   /* Read data from a file */
volatile FRESULT pf_read_sectors (WORD, WORD, WORD);
FRESULT pf_write_sector(void* src);
FRESULT pf_lseek (DWORD);               /* Move file pointer of a file object */
FRESULT pf_opendir (DIR*, const char*); /* Open an existing directory */
FRESULT pf_readdir (DIR*, FILINFO*);    /* Read a directory item */
void pf_grab(FATFS**);

/*--------------------------------------------------------------*/
/* Flags and offset address                                     */

/* File status flag (FATFS.flag) */

#define FA_READ     0x01
#define FA_STREAM   0x40
#define FA__ERROR   0x80
/*FA_STREAM*/
#define	FA__WIP		0x40
#define	FA_OPENED	0x01
#define FR_NOT_OPENED 0x00
/* FAT sub type (FATFS.fs_type) */

#define FS_FAT12    1
#define FS_FAT16    2
#define FS_FAT32    3


/* File attribute bits for directory entry */

#define AM_RDO  0x01    /* Read only */
#define AM_HID  0x02    /* Hidden */
#define AM_SYS  0x04    /* System */
#define AM_VOL  0x08    /* Volume label */
#define AM_LFN  0x0F    /* LFN entry */
#define AM_DIR  0x10    /* Directory */
#define AM_ARC  0x20    /* Archive */
#define AM_MASK 0x3F    /* Mask of defined bits */


/* FatFs refers the members in the FAT structures with byte offset instead
/ of structure member because there are incompatibility of the packing option
/ between various compilers. */

#define BS_jmpBoot          0
#define BS_OEMName          3
#define BPB_BytsPerSec      11
#define BPB_SecPerClus      13
#define BPB_RsvdSecCnt      14
#define BPB_NumFATs         16
#define BPB_RootEntCnt      17
#define BPB_TotSec16        19
#define BPB_Media           21
#define BPB_FATSz16         22
#define BPB_SecPerTrk       24
#define BPB_NumHeads        26
#define BPB_HiddSec         28
#define BPB_TotSec32        32
#define BS_55AA             510

#define BS_DrvNum           36
#define BS_BootSig          38
#define BS_VolID            39
#define BS_VolLab           43
#define BS_FilSysType       54

#define BPB_FATSz32         36
#define BPB_ExtFlags        40
#define BPB_FSVer           42
#define BPB_RootClus        44
#define BPB_FSInfo          48
#define BPB_BkBootSec       50
#define BS_DrvNum32         64
#define BS_BootSig32        66
#define BS_VolID32          67
#define BS_VolLab32         71
#define BS_FilSysType32     82

#define MBR_Table           446

#define DIR_Name            0
#define DIR_Attr            11
#define DIR_NTres           12
#define DIR_CrtTime         14
#define DIR_CrtDate         16
#define DIR_FstClusHI       20
#define DIR_WrtTime         22
#define DIR_WrtDate         24
#define DIR_FstClusLO       26
#define DIR_FileSize        28
#define LDIR_Ord            0
#define LDIR_Attr           11
#define LDIR_Type           12
#define LDIR_Chksum         13
#define LDIR_FstClusLO      26




/*--------------------------------*/
/* Multi-byte word access macros  */

#if _WORD_ACCESS == 1   /* Enable word access to the FAT structure */
#define LD_WORD(ptr)        (WORD)(*(WORD*)(BYTE*)(ptr))
#define LD_DWORD(ptr)       (DWORD)(*(DWORD*)(BYTE*)(ptr))
#define ST_WORD(ptr,val)    *(WORD*)(BYTE*)(ptr)=(WORD)(val)
#define ST_DWORD(ptr,val)   *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
#else                   /* Use byte-by-byte access to the FAT structure */
#define LD_WORD(ptr)        (WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
#define LD_DWORD(ptr)       (DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))
#define ST_WORD(ptr,val)    *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
#define ST_DWORD(ptr,val)   *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
#endif


#endif /* _FATFS */
